#ifndef _M__UTIL__H_
#define _M__UTIL__H_

#include "logger.hpp"
#include <iostream>
#include <string>
#include <sstream>
#include <memory>
#include <fstream>
#include <vector>
#include <mysql/mysql.h>
#include <jsoncpp/json/json.h>

#include<websocketpp/config/asio_no_tls.hpp>
#include<websocketpp/server.hpp>

typedef websocketpp::server<websocketpp::config::asio> wsserver_t;

class mysql_util
{
public:
    // 初始化创建
    static MYSQL *mysql_create(const std::string &host,
                               const std::string &username,
                               const std::string &password,
                               const std::string &dbname,
                               uint16_t port = 3306)
    {
        // 1.初始化mysql句柄
        // MYSQL* mysql_init(MYSQL* mysql);
        MYSQL *mysql = mysql_init(NULL);
        if (mysql == NULL)
        {
            ELOG("mysql init failed!");
            return NULL;
        }

        // 2.连接服务器
        // MYSQL* mysql_real_connect(mysql,host,user,pass,dbname,port,unix_socket,flag);
        if (mysql_real_connect(mysql, host.c_str(), username.c_str(), password.c_str(), dbname.c_str(), port, NULL, 0) == NULL)
        {
            ELOG("connect mysql server failed : %s", mysql_error(mysql));
            mysql_close(mysql);
            return NULL;
        }

        // 3.设置客户端字符集
        // int mysql_set_character_set(mysql,"utf8");
        if (mysql_set_character_set(mysql, "utf8") != 0)
        {
            ELOG("set client character failed : %s", mysql_error(mysql));
            mysql_close(mysql);
            return NULL;
        }

        return mysql;
    }

    // 执行语句
    static bool mysql_exec(MYSQL *mysql, const std::string &sql)
    {
        int ret = mysql_query(mysql,sql.c_str());
        if(ret != 0){
            ELOG("%s",sql.c_str());
            ELOG("mysql query failed : %s",mysql_error(mysql));
            // mysql_close(mysql); 这里会导致重复释放  析构时加执行失败时 则两次释放
            return false;
        }
        return true;
    }

    // 销毁
    static void mysql_destroy(MYSQL *mysql)
    {
        if(mysql != NULL){
            mysql_close(mysql);
        }
        return;
    }
};


class json_util{
    public:
        static bool serialize(const Json::Value& root, std::string& str){
            // 创建工厂类
            Json::StreamWriterBuilder swb;
            
            // 设置emitUTF8选项为true，以输出未转义的UTF-8字符
            swb.settings_["emitUTF8"] = true;

            // 使用智能指针
            std::unique_ptr<Json::StreamWriter> sw(swb.newStreamWriter());
            std::stringstream ss;
            
            int ret = sw->write(root,&ss);
            if(ret != 0){
                ELOG("json serialize failed!");
                return false;
            }
            str = ss.str();
            return true;
        }

        static bool unserialize(const std::string& str,Json::Value& root){
            // 创建工厂类
            Json::CharReaderBuilder crb;
            
            std::unique_ptr<Json::CharReader> cr(crb.newCharReader());

            std::string err;
            bool ret = cr->parse(str.c_str(),str.c_str()+str.size(),&root,&err);
            if(ret == false){
                ELOG("json unserialize failed: %s",err.c_str());
                return false;
            }
            return true;
        }
};

class str_util{
    public:
        static int split(const std::string& src, const std::string& sep, std::vector<std::string>& res){
            // 123,,234,456
            size_t pos, idx = 0; //pos为分割字符串位置 idx为开始寻找位置
            while(idx < src.size()){
                pos = src.find(sep,idx);
                if(pos == std::string::npos){
                    // 即没有找到，字符串中没有间隔字符串了 跳出循环
                    res.push_back(src.substr(idx)); //则从idx截取到结尾
                    break;
                }
                if(pos == idx){
                    // 因为idx会跳过一个分割字符串的大小之后所在位置 pos则是找到下一个字符串开始的所在位置
                    // 所以pos == idx 此时表示下一个位置仍然是分割字符串 需要跳过
                    idx += sep.size();
                    continue;
                }
                res.push_back(src.substr(idx,pos - idx));
                idx = pos + sep.size();
            }

            return res.size();
        }
};

class file_util{
    public:
        static bool read(const std::string& filename,std::string& body){
            //1.打开文件
            std::ifstream ifs(filename,std::ios::binary);
            if(ifs.is_open() == false){
                ELOG("%s file open failed!!",filename.c_str());
                return false;
            }

            //2.获取文件大小
            size_t fsize = 0;
            ifs.seekg(0,std::ios::end); // 从偏移量为0的位置移动到末尾
            fsize = ifs.tellg(); // 再通过tellg获取当前位置 即文件大小
            ifs.seekg(0,std::ios::beg); // 再移动回来
            body.resize(fsize); // 注意设置空间大小

            //3.将文件所有数据读取出来
            ifs.read(&body[0],fsize); // &body[0] 相当于char* 即字符串首地址 因为这里要对body内容进行修改 .c_str()得到的是常字符串 不能修改
            if(ifs.good() == false){ // 用good()状态查看是否读取成功
                ELOG("read %s file content failed!",filename.c_str());
                ifs.close();
                return false;
            }

            //4.关闭文件
            ifs.close();

            return true;
        }

};

#endif